156 research outputs found
Two Compact Incremental Prime Sieves
A prime sieve is an algorithm that finds the primes up to a bound . We say
that a prime sieve is incremental, if it can quickly determine if is
prime after having found all primes up to . We say a sieve is compact if it
uses roughly space or less. In this paper we present two new
results:
(1) We describe the rolling sieve, a practical, incremental prime sieve that
takes time and bits of space, and
(2) We show how to modify the sieve of Atkin and Bernstein (2004) to obtain a
sieve that is simultaneously sublinear, compact, and incremental.
The second result solves an open problem given by Paul Pritchard in 1994
Sieving for pseudosquares and pseudocubes in parallel using doubly-focused enumeration and wheel datastructures
We extend the known tables of pseudosquares and pseudocubes, discuss the
implications of these new data on the conjectured distribution of pseudosquares
and pseudocubes, and present the details of the algorithm used to do this work.
Our algorithm is based on the space-saving wheel data structure combined with
doubly-focused enumeration, run in parallel on a cluster supercomputer
Approximately counting semismooth integers
An integer is -semismooth if where is an integer with
all prime divisors and is 1 or a prime . arge quantities of
semismooth integers are utilized in modern integer factoring algorithms, such
as the number field sieve, that incorporate the so-called large prime variant.
Thus, it is useful for factoring practitioners to be able to estimate the value
of , the number of -semismooth integers up to , so that
they can better set algorithm parameters and minimize running times, which
could be weeks or months on a cluster supercomputer. In this paper, we explore
several algorithms to approximate using a generalization of
Buchstab's identity with numeric integration.Comment: To appear in ISSAC 2013, Boston M
Online Sorting via Searching and Selection
In this paper, we present a framework based on a simple data structure and
parameterized algorithms for the problems of finding items in an unsorted list
of linearly ordered items based on their rank (selection) or value (search). As
a side-effect of answering these online selection and search queries, we
progressively sort the list. Our algorithms are based on Hoare's Quickselect,
and are parameterized based on the pivot selection method.
For example, if we choose the pivot as the last item in a subinterval, our
framework yields algorithms that will answer q<=n unique selection and/or
search queries in a total of O(n log q) average time. After q=\Omega(n) queries
the list is sorted. Each repeated selection query takes constant time, and each
repeated search query takes O(log n) time. The two query types can be
interleaved freely. By plugging different pivot selection methods into our
framework, these results can, for example, become randomized expected time or
deterministic worst-case time. Our methods are easy to implement, and we show
they perform well in practice
Genetic Algorithms for the Extended GCD Problem
We present several genetic algorithms for solving the extended greatest common divisor problem. After defining the problem and discussing previous work, we will state our results
Evidence of comparative efficacy should have a formal role in European drug approvals
Despite methodological concerns, comparative efficacy evidence should be required at the time of drug approval, says Corinna Sorenson and colleagues, to allow patients, clinicians, and other healthcare decision makers to determine whether a new drug is superior, equivalent, or inferior to its existing alternatives
Polylog Depth Circuits for Integer Factoring and Discrete Logarithms
AbstractIn this paper, we develop parallel algorithms for integer factoring and for computing discrete logarithms. In particular, we give polylog depth probabilistic boolean circuits of subexponential size for both of these problems, thereby solving an open problem of Adleman and Kompella.
Existing sequential algorithms for integer factoring and discrete logarithms use a prime base which is the set of all primes up to a bound B. We use a much smaller value for B for our parallel algorithms than is typical for sequential algorithms. In particular, for inputs of length n, by setting B = nlogdn with d a positive constant, we construct
•Probabilistic boolean circuits of depth (log) and size exp[(/log)] for completely factoring a positive integer with probability 1−(1), and
•Probabilistic boolean circuits of depth (log + log) and size exp[(/log)] for computing discrete logarithms in the finite field () for a prime with probability 1−(1). These are the first results of this type for both problem
- …